package com.tedu.API;

import org.junit.Test;

/**
 * Java面向对象---不是面向对象的---八大数据类型
 * 创建对象---类【属性，构造器，方法】
 * 8个包装类：针对八大数据类型提供对应的类【方法基本互通】
 * 八大数据类型都不可改变 final
 * 包位置 java.long
 * 八大数据基本数据类型    针对把大数据类型对应包装类
 * int               Integer   继承Number父类【抽象】
 * long              Long      继承Number父类【抽象】
 * double            Double    继承Number父类【抽象】
 * short             Short     继承Number父类【抽象】
 * float             Float     继承Number父类【抽象】
 * byte              Byte      继承Number父类【抽象】
 * char              Character 继承Object父类【抽象】
 * boolean           Boolean   继承Object父类【抽象】
 */
public class PackingApi {
    @Test
    public void test() {
        int a = 1;  //不是面向对象,通过点调用【反射】
        //创建int类型对象：Integer构造器：引入|直接写
        Integer i = new Integer(a);
        i.toString();
    }

    /**
     * 包装类里的API
     * xxxValue方法==静态方法ValueOf() 返回值为对应的数据类型
     * 作用：把包装类转换为基本数据类型
     * 测试六个包装类
     */
    @Test
    public void testXxxInteger() {
        Integer i = new Integer(2);  //打包，把对用数据类型放入包装类
        i.intValue();  //接收：int类型和Integer
        System.out.println(i);
        //测试其他包装类
        String s1 = "123.123";
        Double d = new Double(s1);
        d.doubleValue();
        System.out.println(s1);

        String s2 = "1";
        Byte b = new Byte(s2);
        b.byteValue();
        System.out.println(b);

        String s3 = "123.123F";
        Float f = new Float(s3);
        f.floatValue();
        System.out.println(f);

        String s4 = "1234L";
        Long l = new Long(1234L);
        //包装类构造器：直接传值，【使用字符串传值：long包装认为l字符，并不是数值】
        long L = l.longValue();
        System.out.println(l);

        String s5 = "true";
        Boolean B = new Boolean(s5);
        B.booleanValue();
        System.out.println(B);

        char s6 = 'a';
        Character c = new Character('a');
        c.charValue();
        System.out.println(s6);
    }

    /**
     * 包装类都具备静态方法
     * valueOf()  返回值对应数据类型
     * 作用：把包装类转换为数据类型方法
     */
    @Test
    public void testValueOf() {
        int i = Integer.valueOf(1);  //打包拆包一起
        Boolean.valueOf(true);  //拆包
        char c = Character.valueOf('a');
        float f = Float.valueOf(123.123F);
    }

    /**
     * 包装类----Servlet[javaBean==实体类]
     * <p>
     * public class Person{
     * Integer id; //成员变量---解析
     * }
     * <p>
     * 异常：java.lang.NumberFormatException 解析字符串异常
     * parseXXX()  静态方法 返回值 对应的类型
     * 作用：将获取到的字符串转换为对应的类型
     */
    @Test
    public void testParseXXX() {
        String s = "123";  //将字符串转换为整型
        int i = Integer.parseInt(s);  //区别：解析字符串，转换为正确的类型
        int is = Integer.valueOf(s);  //区别：存入对应的值，打包拆包的方式获取值
        System.out.println(is == i);
        //将整型转换为字符串
        String s1 = String.valueOf(123);  //与包装类，用法一致，方法内部实现不一致
        //测试
        String s2 = "456f";
        float f = Float.parseFloat(s2);
        System.out.println(f);
        String s3 = "a";
        //Character 没有针对字符的解析
    }

    /**
     * 自动拆装箱
     * JDK1.5之前没有自动拆装箱 2004年出现
     */
    @Test
    public void testJ() {
        //1.5之前
        Integer in = Integer.valueOf(1); //装箱
        int ii = in.intValue(); //拆箱
        //JDK1.5后 自动拆装箱
        Integer i = 1;
        int is = i;
        //编译器帮我们写拆箱过程---JVM只认识1.5之前的写法
    }

}
